﻿
#include "Engine/common.h"
#include "Engine/uimgr.h"
#include "Engine/ControlDef.h"
#include "strid.h"
#include "DNF定义.h"
#include "DNF对象定义.h"
#include "AppUI.h"
#include "设置模块.h"

CImage* Ctrl技能面板;
std::vector<int> 符文ResID缓存;

const int 纵向间距=16;
const int 行宽=技能面板宽度;	//684
const int 标题高度=28;
const int 标题宽度=660;
const int 标题偏移X=(行宽-660)/2;

int 护石符文变更回调(UIControl* CtrlObj,UIEvent_t UIEvent,PVOID Param1,PVOID Param2);
int 技能变更回调(UIControl* CtrlObj,UIEvent_t UIEvent,PVOID Param1,PVOID Param2);

void 详细构建_技能面板(int PageId,CImage* Ctrl技能面板)
{
	::Ctrl技能面板=Ctrl技能面板;

	int NextX=0;
	int NextY=纵向间距;
	SetCreateControlParam(标题偏移X,NextY,Ctrl技能面板,PageId_Setting);
	CImage* Ctrl标题_护石符文=EasyCreateImage(CID_技能_护石符文标题,标题宽度,标题高度,RID_技能区标题_护石符文);
	NextY+=标题高度+纵向间距;

	//护石符文分3列，每列分别是护石，符文颜色1，符文1，符文颜色2，符文2，符文颜色3，符文3
	int 护石符文左右边距=30;
	int 护石符文上下边距=6;
	int 护石符文宽度=行宽/3-护石符文左右边距*2;	//每个占1/3宽度
	int 护石符文所占高度=38+护石符文上下边距*2;	//控件高38，上下边距12
	for (int i=0;i<3;i++)
	{
		SetCreateControlParam(行宽/3*i+护石符文左右边距,NextY+护石符文上下边距,Ctrl技能面板,PageId_Setting);
		CDropList* Ctrl护石=EasyCreateDropList(CID_技能_护石1+i,护石符文宽度,TRUE);
		Ctrl护石->SetUserData((PVOID)((0<<16)|i));
		Ctrl护石->SetEventHandler(护石符文变更回调);

		for (int j=0;j<3;j++)
		{
			int 符文颜色Y=NextY+护石符文所占高度+护石符文所占高度*(j*2)+护石符文上下边距;
			SetCreateControlParam(行宽/3*i+护石符文左右边距,符文颜色Y,Ctrl技能面板,PageId_Setting);
			CDropList* Ctrl符文颜色=EasyCreateDropList(CID_技能_符文颜色1_1+i*3+j,护石符文宽度,TRUE);
			Ctrl符文颜色->SetUserData((PVOID)((1<<16)|(i*3+j)));
			Ctrl符文颜色->SetEventHandler(护石符文变更回调);

			int 符文Y=NextY+护石符文所占高度+护石符文所占高度*(j*2+1);		//符文和符文颜色间少一个上边距强调关系
			SetCreateControlParam(行宽/3*i+护石符文左右边距,符文Y,Ctrl技能面板,PageId_Setting);
			CDropList* Ctrl符文=EasyCreateDropList(CID_技能_符文1_1+i*3+j,护石符文宽度,TRUE);
			Ctrl符文->SetUserData((PVOID)((2<<16)|(i*3+j)));
			Ctrl符文->SetEventHandler(护石符文变更回调);
		}
	}

	NextY+=护石符文所占高度*7+纵向间距*2-护石符文上下边距*3;
	SetCreateControlParam(标题偏移X,NextY,Ctrl技能面板,PageId_Setting);
	CImage* Ctrl标题_技能=EasyCreateImage(CID_技能_技能标题,标题宽度,标题高度,RID_技能区标题_技能);
	NextY+=标题高度+纵向间距;

	//主动技能，从左到右分别是：技能图标，技能等级，技能TP等级，技能次数，宠物次数，手搓次数，手搓方向键数量，快捷栏
	//被动技能，一行5个，图标和等级交替
	//最后是Buff图标和输入框
	//技能不满槽位会隐藏相关控件，最下面会空出一块，由于技能面板高度固定，无法调整，所以槽位没敢留太多
	const int 技能设置左右边距=28;
	const int 技能设置横向间隔=18;
	const int 选择框宽度=20;		//没有字，坐标2右边4中间框16
	const int 选择框横向间隔=20;
	const int 技能设置控件宽度=(行宽-技能设置左右边距*2-技能设置横向间隔*6-28-22-选择框横向间隔)/6;
	const int 技能设置所占高度=28+2+2;	//以图标为基准，上下空4
	const int 技能设置纵向间隔=6;
	const int 下拉列表偏移Y=技能设置所占高度/2-24/2;
	const int 编辑框偏移Y=技能设置所占高度/2-22/2;
	const int 选择框偏移Y=技能设置所占高度/2-20/2;
	SetCreateControlParam(NextX,NextY,Ctrl技能面板,PageId_Setting);
	CImage* Ctrl技能设置描述=EasyCreateImage(CID_技能_技能设置描述,行宽,16,RID_技能设置描述);
	NextY+=16+8;
	for (int i=0;i<20;i++)
	{
		NextX=技能设置左右边距;
		SetCreateControlParam(NextX,NextY+2,Ctrl技能面板,PageId_Setting);
		CImage* Ctrl技能图标=EasyCreateImage(CID_技能_技能图标+i,28,28);
		NextX+=28+技能设置横向间隔;

		SetCreateControlParam(NextX,NextY+下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
		CDropList* Ctrl技能等级=EasyCreateDropList(CID_技能_技能等级+i,技能设置控件宽度,FALSE);
		Ctrl技能等级->SetUserData((PVOID)((0<<16)|i));
		Ctrl技能等级->SetEventHandler(技能变更回调);
		NextX+=技能设置控件宽度+技能设置横向间隔;
		
		SetCreateControlParam(NextX,NextY+下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
		CDropList* Ctrl技能TP等级=EasyCreateDropList(CID_技能_技能TP等级+i,技能设置控件宽度,FALSE);
		Ctrl技能TP等级->SetUserData((PVOID)((1<<16)|i));
		Ctrl技能TP等级->SetEventHandler(技能变更回调);
		NextX+=技能设置控件宽度+技能设置横向间隔;

		SetCreateControlParam(NextX,NextY+编辑框偏移Y,Ctrl技能面板,PageId_Setting);
		CEdit* Ctrl技能次数=EasyCreateEdit(CID_技能_技能次数+i,技能设置控件宽度);
		Ctrl技能次数->SetUserData((PVOID)((2<<16)|i));
		Ctrl技能次数->SetEventHandler(技能变更回调);
		NextX+=技能设置控件宽度+技能设置横向间隔;

		SetCreateControlParam(NextX,NextY+编辑框偏移Y,Ctrl技能面板,PageId_Setting);
		CEdit* Ctrl技能宠物次数=EasyCreateEdit(CID_技能_技能宠物次数+i,技能设置控件宽度);
		Ctrl技能宠物次数->SetUserData((PVOID)((3<<16)|i));
		Ctrl技能宠物次数->SetEventHandler(技能变更回调);
		NextX+=技能设置控件宽度+技能设置横向间隔;

		SetCreateControlParam(NextX,NextY+编辑框偏移Y,Ctrl技能面板,PageId_Setting);
		CEdit* Ctrl技能手搓次数=EasyCreateEdit(CID_技能_技能手搓次数+i,技能设置控件宽度);
		Ctrl技能手搓次数->SetUserData((PVOID)((4<<16)|i));
		Ctrl技能手搓次数->SetEventHandler(技能变更回调);
		NextX+=技能设置控件宽度+技能设置横向间隔;

		SetCreateControlParam(NextX,NextY+下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
		CDropList* Ctrl手搓方向键=EasyCreateDropList(CID_技能_技能手搓方向键+i,技能设置控件宽度,FALSE);
		Ctrl手搓方向键->SetUserData((PVOID)((5<<16)|i));
		Ctrl手搓方向键->SetEventHandler(技能变更回调);
		NextX+=技能设置控件宽度+选择框横向间隔;

		SetCreateControlParam(NextX,NextY+下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
		CCheckBox* Ctrl技能在快捷栏=EasyCreateCheckBox(CID_技能_技能在快捷栏+i,NULL);
		Ctrl技能在快捷栏->SetUserData((PVOID)((9<<16)|i));
		Ctrl技能在快捷栏->SetEventHandler(技能变更回调);
		NextX+=选择框宽度+技能设置横向间隔;

		NextY+=技能设置所占高度;
		NextY+=技能设置纵向间隔;
	}

	const int 被动技能设置左右边距=28;
	const int 被动技能设置横向小间隔=10;
	const int 被动技能设置横向大间隔=20;
	const int 被动技能设置控件宽度=(行宽-被动技能设置左右边距*2-被动技能设置横向小间隔*5-被动技能设置横向大间隔*4-28*5)/5;
	const int 被动技能设置所占高度=28+4+4;
	const int 被动技能设置纵向间隔=6;
	const int 被动下拉列表偏移Y=被动技能设置所占高度/2-24/2;
	NextY+=被动技能设置纵向间隔;
	NextX=被动技能设置左右边距;
	for (int i=0;i<5;i++)
	{
		SetCreateControlParam(NextX,NextY+4,Ctrl技能面板,PageId_Setting);
		CImage* Ctrl被动技能图标=EasyCreateImage(CID_技能_被动技能图标+i,28,28);
		NextX+=28+被动技能设置横向小间隔;

		SetCreateControlParam(NextX,NextY+被动下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
		CDropList* Ctrl被动技能等级=EasyCreateDropList(CID_技能_被动技能等级+i,被动技能设置控件宽度,FALSE);
		Ctrl被动技能等级->SetUserData((PVOID)((6<<16)|i));
		Ctrl被动技能等级->SetEventHandler(技能变更回调);
		NextX+=被动技能设置控件宽度+被动技能设置横向大间隔;

	}
	NextY+=被动技能设置所占高度+被动技能设置纵向间隔;
	NextX=被动技能设置左右边距;
	for (int i=0;i<5;i++)
	{
		SetCreateControlParam(NextX,NextY+4,Ctrl技能面板,PageId_Setting);
		CImage* Ctrl被动技能图标=EasyCreateImage(CID_技能_被动技能图标+i+5,28,28);
		NextX+=28+被动技能设置横向小间隔;

		SetCreateControlParam(NextX,NextY+被动下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
		CDropList* Ctrl被动技能等级=EasyCreateDropList(CID_技能_被动技能等级+i+5,被动技能设置控件宽度,FALSE);
		Ctrl被动技能等级->SetUserData((PVOID)((6<<16)|(i+5)));
		Ctrl被动技能等级->SetEventHandler(技能变更回调);
		NextX+=被动技能设置控件宽度+被动技能设置横向大间隔;
	}
	NextY+=被动技能设置所占高度+被动技能设置纵向间隔;
	NextX=被动技能设置左右边距;

	SetCreateControlParam(NextX,NextY+4,Ctrl技能面板,PageId_Setting);
	CImage* CtrlBuff技能图标=EasyCreateImage(CID_技能_Buff技能图标,28,28);
	NextX+=28+被动技能设置横向小间隔;

	SetCreateControlParam(NextX,NextY+被动下拉列表偏移Y,Ctrl技能面板,PageId_Setting);
	CEdit* CtrlBuff技能数值=EasyCreateEdit(CID_技能_Buff技能数值,被动技能设置控件宽度);
	CtrlBuff技能数值->SetUserData((PVOID)((7<<16)|0));
	CtrlBuff技能数值->SetEventHandler(技能变更回调);
	NextX+=被动技能设置控件宽度+被动技能设置横向大间隔;
	NextY+=被动技能设置所占高度+被动技能设置纵向间隔*2;

	//职业特殊设置是CheckBox，一行2个
	//如果没有职业特殊设置，这里可以隐藏，不过能确定奶妈和剑帝都有
	//即使隐藏，技能面板的高度也不会自动调整，最底下会空出一块，所以槽位没敢留太多
	SetCreateControlParam(标题偏移X,NextY,Ctrl技能面板,PageId_Setting);
	CImage* Ctrl标题_职业设置=EasyCreateImage(CID_技能_职业设置标题,标题宽度,标题高度,RID_技能区标题_职业设置);
	NextY+=标题高度+纵向间距;

	NextX=被动技能设置左右边距;
	SetCreateControlParam(NextX,NextY,Ctrl技能面板,PageId_Setting);
	CCheckBox* Ctrl技能特殊设置1=EasyCreateCheckBox(CID_技能_特殊设置1,L"特殊设置1");
	Ctrl技能特殊设置1->SetTextColor(0xFF000000);
	Ctrl技能特殊设置1->SetUserData((PVOID)((8<<16)|0));
	Ctrl技能特殊设置1->SetEventHandler(技能变更回调);

	NextX=被动技能设置左右边距+行宽/2;
	SetCreateControlParam(NextX,NextY,Ctrl技能面板,PageId_Setting);
	CCheckBox* Ctrl技能特殊设置2=EasyCreateCheckBox(CID_技能_特殊设置2,L"特殊设置2");
	Ctrl技能特殊设置2->SetTextColor(0xFF000000);
	Ctrl技能特殊设置2->SetUserData((PVOID)((8<<16)|1));
	Ctrl技能特殊设置2->SetEventHandler(技能变更回调);
}


void 护石互斥检查()
{
	//3个槽不允许选择相同护石
	CDropList* Ctrl护石1=EasyFindControl<CDropList>(PageId_Setting,CID_技能_护石1+0);
	CDropList* Ctrl护石2=EasyFindControl<CDropList>(PageId_Setting,CID_技能_护石1+1);
	CDropList* Ctrl护石3=EasyFindControl<CDropList>(PageId_Setting,CID_技能_护石1+2);
	int ItemNum=Ctrl护石1->GetItemNum();		//3个列表护石数量一样
	for (int i=0;i<ItemNum;i++)
	{
		Ctrl护石1->EnableItem(i,TRUE);
		Ctrl护石2->EnableItem(i,TRUE);
		Ctrl护石3->EnableItem(i,TRUE);
	}
	CDropList* Ctrl当前护石;
	CDropList* Ctrl目标护石1;
	CDropList* Ctrl目标护石2;
	for (int i=0;i<3;i++)
	{
		if (i==0)
		{
			Ctrl当前护石=Ctrl护石1;
			Ctrl目标护石1=Ctrl护石2;
			Ctrl目标护石2=Ctrl护石3;
		}
		else if (i==1)
		{
			Ctrl当前护石=Ctrl护石2;
			Ctrl目标护石1=Ctrl护石1;
			Ctrl目标护石2=Ctrl护石3;
		}
		else if (i==2)
		{
			Ctrl当前护石=Ctrl护石3;
			Ctrl目标护石1=Ctrl护石1;
			Ctrl目标护石2=Ctrl护石2;
		}
		int 选择索引=Ctrl当前护石->GetSelect();
		Ctrl目标护石1->EnableItem(选择索引,FALSE);
		Ctrl目标护石2->EnableItem(选择索引,FALSE);
	}
}

void 符文颜色互斥检查(int 所属护石)
{
	//同一个槽下的3个符文技能可以相同，但颜色不能相同
	int i=所属护石;
	CDropList* Ctrl符文颜色1=EasyFindControl<CDropList>(PageId_Setting,CID_技能_符文颜色1_1+i*3+0);
	CDropList* Ctrl符文颜色2=EasyFindControl<CDropList>(PageId_Setting,CID_技能_符文颜色1_1+i*3+1);
	CDropList* Ctrl符文颜色3=EasyFindControl<CDropList>(PageId_Setting,CID_技能_符文颜色1_1+i*3+2);
	int ItemNum=Ctrl符文颜色1->GetItemNum();		//3个列表符文数量一样
	for (int j=0;j<ItemNum;j++)
	{
		Ctrl符文颜色1->EnableItem(j,TRUE);
		Ctrl符文颜色2->EnableItem(j,TRUE);
		Ctrl符文颜色3->EnableItem(j,TRUE);
	}
	CDropList* Ctrl当前符文颜色;
	CDropList* Ctrl目标符文颜色1;
	CDropList* Ctrl目标符文颜色2;
	for (int j=0;j<3;j++)
	{
		if (j==0)
		{
			Ctrl当前符文颜色=Ctrl符文颜色1;
			Ctrl目标符文颜色1=Ctrl符文颜色2;
			Ctrl目标符文颜色2=Ctrl符文颜色3;
		}
		else if (j==1)
		{
			Ctrl当前符文颜色=Ctrl符文颜色2;
			Ctrl目标符文颜色1=Ctrl符文颜色1;
			Ctrl目标符文颜色2=Ctrl符文颜色3;
		}
		else if (j==2)
		{
			Ctrl当前符文颜色=Ctrl符文颜色3;
			Ctrl目标符文颜色1=Ctrl符文颜色1;
			Ctrl目标符文颜色2=Ctrl符文颜色2;
		}
		int 选择索引=Ctrl当前符文颜色->GetSelect();
		Ctrl目标符文颜色1->EnableItem(选择索引,FALSE);
		Ctrl目标符文颜色2->EnableItem(选择索引,FALSE);
	}
}

void 职业符文特殊处理(CDropList* Ctrl符文)
{
	//文档要求所有符文护石，这些可选择但无效
	if (CurrentJob==职业_光明骑士女)
	{
		Ctrl符文->AppendItem(L"治愈祈祷");
		符文ResID缓存.push_back(RID_符文图标_奶妈+(圣光普照符文+1)*5);
		Ctrl符文->AppendItem(L"新生颂歌");
		符文ResID缓存.push_back(RID_符文图标_奶妈+(圣光普照符文+2)*5);
	}
	else if (CurrentJob==职业_流浪武士)
	{
		Ctrl符文->AppendItem(L"三才剑");
		符文ResID缓存.push_back(RID_符文图标_剑帝+(樱花劫符文+1)*5);
		Ctrl符文->AppendItem(L"轮回剑");
		符文ResID缓存.push_back(RID_符文图标_剑帝+(樱花劫符文+2)*5);
	}
}

void 符文颜色调整(int 所属护石,int 所属符文,int 颜色索引)
{
	CDropList* Ctrl符文=EasyFindControl<CDropList>(PageId_Setting,CID_技能_符文1_1+所属护石*3+所属符文);
	int ItemNum=Ctrl符文->GetItemNum();
	for (int i=0;i<ItemNum;i++)
		Ctrl符文->SetItemIcon(i,EasyLoadImageR(符文ResID缓存[i]+颜色索引));
}




void 重置设置_技能面板()
{
	UI_AdjustState++;

	//护石符文
	符文ResID缓存.clear();
	for (int i=0;i<3;i++)
	{
		CDropList* Ctrl护石=EasyFindControl<CDropList>(PageId_Setting,CID_技能_护石1+i);
		Ctrl护石->ClearItem();
		std::vector<DNF技能对象*>::iterator it;
		for (it=技能对象表.begin();it!=技能对象表.end();it++)
		{
			DNF技能对象* 技能对象=*it;
			if (技能对象->所属职业==CurrentJob && 技能对象->可用护石)
			{
				int Index=Ctrl护石->AppendItem(技能对象->名称);
				Ctrl护石->SetItemIcon(Index,EasyLoadImageR(技能对象->ResId));
			}
		}
		Ctrl护石->SetSelect(GetIndexSetting(设置_护石1+i));

		for (int j=0;j<3;j++)
		{
			CDropList* Ctrl符文颜色=EasyFindControl<CDropList>(PageId_Setting,CID_技能_符文颜色1_1+i*3+j);
			Ctrl符文颜色->ClearItem();
			for (int k=0;k<5;k++)
			{
				Ctrl符文颜色->AppendItem(符文颜色文本[k]);
				Ctrl符文颜色->SetItemIcon(k,EasyLoadImageR(RID_符文红色+k));
			}
			Ctrl符文颜色->SetSelect(GetIndexSetting(设置_符文1颜色+i*3+j));

			CDropList* Ctrl符文=EasyFindControl<CDropList>(PageId_Setting,CID_技能_符文1_1+i*3+j);
			Ctrl符文->ClearItem();
			for (it=技能对象表.begin();it!=技能对象表.end();it++)
			{
				DNF技能对象* 技能对象=*it;
				if (技能对象->所属职业==CurrentJob && 技能对象->可用符文)
				{
					int Index=Ctrl符文->AppendItem(技能对象->名称);
					符文ResID缓存.push_back(技能对象->符文起始ResId);
				}
			}
			职业符文特殊处理(Ctrl符文);
			Ctrl符文->SetSelect(GetIndexSetting(设置_符文1+i*3+j));
			符文颜色调整(i,j,Ctrl符文颜色->GetSelect());	//在这里根据颜色统一修改图标
		}
		符文颜色互斥检查(i);
	}
	护石互斥检查();


	auto AddItemBatch=[](CDropList* CtrlDropList,WCHAR* FmtText,int Begin,int Step,int BatchNum)->void
	{
		CtrlDropList->ClearItem();
		WCHAR Buf[10];
		for (int i=0;i<BatchNum;i++)
		{
			swprintf(Buf,FmtText,Begin);
			CtrlDropList->AppendItem(Buf);
			Begin+=Step;
		}
	};
	//主动技能
	for (int i=0;i<20;i++)
	{
		CImage* Ctrl技能图标=EasyFindControl<CImage>(PageId_Setting,CID_技能_技能图标+i);
		CDropList* Ctrl技能等级=EasyFindControl<CDropList>(PageId_Setting,CID_技能_技能等级+i);
		CDropList* Ctrl技能TP等级=EasyFindControl<CDropList>(PageId_Setting,CID_技能_技能TP等级+i);
		CEdit* Ctrl技能次数=EasyFindControl<CEdit>(PageId_Setting,CID_技能_技能次数+i);
		CEdit* Ctrl技能宠物次数=EasyFindControl<CEdit>(PageId_Setting,CID_技能_技能宠物次数+i);
		CEdit* Ctrl技能手搓次数=EasyFindControl<CEdit>(PageId_Setting,CID_技能_技能手搓次数+i);
		CDropList* Ctrl手搓方向键=EasyFindControl<CDropList>(PageId_Setting,CID_技能_技能手搓方向键+i);
		CCheckBox* Ctrl技能在快捷栏=EasyFindControl<CCheckBox>(PageId_Setting,CID_技能_技能在快捷栏+i);
		if (i<当前职业对象->主动技能数量)
		{		
			Ctrl技能图标->SetImage(EasyLoadImageR(当前职业对象->职业技能列表[i]->ResId));
			Ctrl技能图标->SetVisible(TRUE);

			AddItemBatch(Ctrl技能等级,L"%d",0,1,当前职业对象->职业技能列表[i]->等级上限+1);
			Ctrl技能等级->SetSelect(GetIndexSetting(设置_主动技能1等级+i));
			Ctrl技能等级->SetVisible(TRUE);	

			Ctrl技能TP等级->SetVisible(FALSE);
			if (当前职业对象->职业技能列表[i]->可用TP)
			{
				AddItemBatch(Ctrl技能TP等级,L"%d",0,1,当前职业对象->职业技能列表[i]->TP等级上限+1);
				Ctrl技能TP等级->SetSelect(GetIndexSetting(设置_主动技能1TP等级+i));
				Ctrl技能TP等级->SetVisible(TRUE);
			}
			
			ResetEdit(设置_主动技能1次数+i,CID_技能_技能次数+i,PageId_Setting);
			Ctrl技能次数->SetVisible(TRUE);

			ResetEdit(设置_主动技能1宠物次数+i,CID_技能_技能宠物次数+i,PageId_Setting);
			Ctrl技能宠物次数->SetVisible(TRUE);

			ResetEdit(设置_主动技能1手搓次数+i,CID_技能_技能手搓次数+i,PageId_Setting);
			Ctrl技能手搓次数->SetVisible(TRUE);
			
			if (Ctrl手搓方向键->GetItemNum()==0)	//方向键数量所有职业固定为0~4
				AddItemBatch(Ctrl手搓方向键,L"%d",0,1,5);
			Ctrl手搓方向键->SetSelect(GetIndexSetting(设置_主动技能1手搓方向键数量+i));
			Ctrl手搓方向键->SetVisible(TRUE);

			Ctrl技能在快捷栏->SetCheck(GetIndexSetting(设置_主动技能1在快捷栏+i));
			Ctrl技能在快捷栏->SetVisible(TRUE);
		}
		else
		{
			Ctrl技能图标->SetVisible(FALSE);
			Ctrl技能等级->SetVisible(FALSE);
			Ctrl技能TP等级->SetVisible(FALSE);
			Ctrl技能次数->SetVisible(FALSE);
			Ctrl技能宠物次数->SetVisible(FALSE);
			Ctrl技能手搓次数->SetVisible(FALSE);	
			Ctrl手搓方向键->SetVisible(FALSE);
			Ctrl技能在快捷栏->SetVisible(FALSE);
		}
	}
	//被动技能
	for (int i=0;i<10;i++)
	{
		CImage* Ctrl被动技能图标=EasyFindControl<CImage>(PageId_Setting,CID_技能_被动技能图标+i);
		CDropList* Ctrl被动技能等级=EasyFindControl<CDropList>(PageId_Setting,CID_技能_被动技能等级+i);
		if (i<当前职业对象->被动技能数量)
		{
			Ctrl被动技能图标->SetImage(EasyLoadImageR(当前职业对象->职业技能列表[当前职业对象->被动技能索引+i]->ResId));
			Ctrl被动技能图标->SetVisible(TRUE);

			AddItemBatch(Ctrl被动技能等级,L"%d",0,1,当前职业对象->职业技能列表[当前职业对象->被动技能索引+i]->等级上限+1);
			Ctrl被动技能等级->SetSelect(GetIndexSetting(设置_被动技能1等级+i));
			Ctrl被动技能等级->SetVisible(TRUE);
		}
		else
		{
			Ctrl被动技能图标->SetVisible(FALSE);
			Ctrl被动技能等级->SetVisible(FALSE);
		}
	}
	//Buff技能
	CImage* CtrlBuff技能图标=EasyFindControl<CImage>(PageId_Setting,CID_技能_Buff技能图标);
	CDropList* CtrlBuff技能数值=EasyFindControl<CDropList>(PageId_Setting,CID_技能_Buff技能数值);

	CtrlBuff技能图标->SetImage(EasyLoadImageR(当前职业对象->Buff图标ResId));
	CtrlBuff技能图标->SetVisible(TRUE);

	ResetEdit(设置_职业Buff技能提升率,CID_技能_Buff技能数值,PageId_Setting);
	CtrlBuff技能数值->SetVisible(TRUE);

	//职业特殊设置
	//有些设置项意义不大，就不添加了，比如[奶妈]启用天赋增强的圣佑之阵，[剑帝]跳跃施放莲花剑舞
	CCheckBox* Ctrl技能特殊设置1=EasyFindControl<CCheckBox>(PageId_Setting,CID_技能_特殊设置1);
	CCheckBox* Ctrl技能特殊设置2=EasyFindControl<CCheckBox>(PageId_Setting,CID_技能_特殊设置2);
	if (CurrentJob==职业_光明骑士女)
	{
		Ctrl技能特殊设置1->SetText(L"一觉柔化");
		Ctrl技能特殊设置1->SetCheck(GetIndexSetting(设置_奶妈特殊设置1));
	}
	else if (CurrentJob==职业_流浪武士)
	{
		Ctrl技能特殊设置1->SetText(L"仍有余力无需加强");
		Ctrl技能特殊设置1->SetCheck(GetIndexSetting(设置_剑帝特殊设置1));
	}
	Ctrl技能特殊设置1->SetVisible(TRUE);
	Ctrl技能特殊设置2->SetVisible(FALSE);

	UI_AdjustState--;
}

void 退出清理_技能面板()
{
	符文ResID缓存.clear();
}




int 护石符文变更回调(UIControl* CtrlObj,UIEvent_t UIEvent,PVOID Param1,PVOID Param2)
{
	if (UI_AdjustState!=0)
		return 0;
	if (UIEvent==EvtSelectChange)
	{
		int v=(int)CtrlObj->GetUserData();
		int Index=(int)Param1;
		int Type=HIWORD(v);
		int 所属护石=LOWORD(v);
		if (Type==0)	//护石
		{
			UI_AdjustState++;
			护石互斥检查();
			UI_AdjustState--;
			ChangeSettingByUI_Index(设置_护石1+所属护石,Index);
			SubmitSettingChange();
		}
		else if (Type==1)	//符文颜色
		{
			int 所属符文=所属护石%3;
			所属护石=所属护石/3;

			UI_AdjustState++;
			符文颜色互斥检查(所属护石);
			符文颜色调整(所属护石,所属符文,Index);
			UI_AdjustState--;
			ChangeSettingByUI_Index(设置_符文1颜色+所属护石*3+所属符文,Index);
			SubmitSettingChange();
		}
		else if (Type==2)	//符文
		{
			int 所属符文=所属护石%3;
			所属护石=所属护石/3;
			ChangeSettingByUI_Index(设置_符文1+所属护石*3+所属符文,Index);
			SubmitSettingChange();
		}
	}
	return 0;
}

int 技能变更回调(UIControl* CtrlObj,UIEvent_t UIEvent,PVOID Param1,PVOID Param2)
{
	if (UI_AdjustState!=0)
		return 0;
	int v=(int)CtrlObj->GetUserData();
	int Type=HIWORD(v);
	int CtrlIndex=LOWORD(v);
	//预留了足够的槽位，不一定都用上，范围之外的设置项加载时不会用到，也不会产生变更通知
	if (UIEvent==EvtSelectChange)
	{
		int Index=(int)Param1;
		int SettingIndex=-1;
		if (Type==0)	//技能等级
			SettingIndex=设置_主动技能1等级+CtrlIndex;
		else if (Type==1)	//技能TP等级
			SettingIndex=设置_主动技能1TP等级+CtrlIndex;
		else if (Type==5)	//手搓方向键数量
			SettingIndex=设置_主动技能1手搓方向键数量+CtrlIndex;
		else if (Type==6)	//被动技能等级
			SettingIndex=设置_被动技能1等级+CtrlIndex;
		ChangeSettingByUI_Index(SettingIndex,Index);
		SubmitSettingChange();
	}
	else if (UIEvent==EvtEditChange)
	{
		WCHAR* Text=(WCHAR*)Param1;
		int Len=(int)Param2;
		float Value=0.0f;
		int SettingIndex=-1;
		UI_AdjustState++;
		if (Type==2)	//技能次数
		{
			Value=EditChangeAdjust((CEdit*)CtrlObj,Text,Len,-1,TRUE);
			SettingIndex=设置_主动技能1次数+CtrlIndex;
			//修改技能次数后，将宠物和手搓次数也设为相同值
			//手搓和宠物都不应该是默认选项，转换函数已经做出超出范围的限制，这里不画蛇添足了
			//WCHAR Buf[100];
			//CEdit* Ctrl技能次数=(CEdit*)CtrlObj;
			//Ctrl技能次数->GetText(Buf,100);
			//CEdit* Ctrl技能宠物次数=EasyFindControl<CEdit>(PageId_Setting,CID_技能_技能宠物次数+CtrlIndex);
			//CEdit* Ctrl技能手搓次数=EasyFindControl<CEdit>(PageId_Setting,CID_技能_技能手搓次数+CtrlIndex);
			//Ctrl技能宠物次数->SetText(Buf);
			//Ctrl技能手搓次数->SetText(Buf);
			//ChangeSettingByUI_Value(设置_主动技能1宠物次数+CtrlIndex,Value);
			//ChangeSettingByUI_Value(设置_主动技能1手搓次数+CtrlIndex,Value);
		}
		else if (Type==3)	//宠物次数
		{
			Value=EditChangeAdjust((CEdit*)CtrlObj,Text,Len,-1,TRUE);
			SettingIndex=设置_主动技能1宠物次数+CtrlIndex;
		}
		else if (Type==4)	//手搓次数
		{
			Value=EditChangeAdjust((CEdit*)CtrlObj,Text,Len,-1,TRUE);
			SettingIndex=设置_主动技能1手搓次数+CtrlIndex;
		}
		else if (Type==7)	//Buff技能数值
		{
			Value=EditChangeAdjust((CEdit*)CtrlObj,Text,Len,1,TRUE);
			SettingIndex=设置_职业Buff技能提升率;
		}
		UI_AdjustState--;
		ChangeSettingByUI_Value(SettingIndex,Value);
		SubmitSettingChange();
	}
	else if (UIEvent==EvtCheckBoxChange)
	{
		int CheckIndex=(int)Param1;
		if (Type==8)	//职业特殊设置1
		{
			if (CurrentJob==职业_光明骑士女)
				ChangeSettingByUI_Index(设置_奶妈特殊设置1+CtrlIndex,CheckIndex);
			else if (CurrentJob==职业_流浪武士)
				ChangeSettingByUI_Index(设置_剑帝特殊设置1+CtrlIndex,CheckIndex);
			SubmitSettingChange();
		}
		else if (Type==9)	//技能在快捷栏
		{
			ChangeSettingByUI_Index(设置_主动技能1在快捷栏+CtrlIndex,CheckIndex);
			SubmitSettingChange();
		}
	}
	return 0;
}


int 获取护石对应技能索引(int 技能区索引)
{
	int 技能索引=0;
	int 技能区索引计数=0;
	std::vector<DNF技能对象*>::iterator it;
	for (it=技能对象表.begin();it!=技能对象表.end();it++)
	{
		DNF技能对象* 技能对象=*it;
		if (技能对象->所属职业==CurrentJob)
		{
			if (技能对象->可用护石)
			{
				if (技能区索引==技能区索引计数)
					return 技能索引;
				技能区索引计数++;
			}
			技能索引++;
		}
	}
	return -1;
}

int 获取符文对应技能索引(int 技能区索引)
{
	int 技能索引=0;
	int 技能区索引计数=0;
	std::vector<DNF技能对象*>::iterator it;
	for (it=技能对象表.begin();it!=技能对象表.end();it++)
	{
		DNF技能对象* 技能对象=*it;
		if (技能对象->所属职业==CurrentJob)
		{
			if (技能对象->可用符文)
			{
				if (技能区索引==技能区索引计数)
					return 技能索引;
				技能区索引计数++;
			}
			技能索引++;
		}
	}
	//会忽略额外添加的符文
	return -1;
}
